home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / p4 / p4-1_2a.lha / p4-1.2a / contrib / sockperf.c < prev   
C/C++ Source or Header  |  1992-10-19  |  6KB  |  288 lines
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <netdb.h>
  5. #include <netinet/in.h>
  6. #include <errno.h>
  7. #include <sys/time.h>
  8. #include <fcntl.h>
  9. #include <netinet/tcp.h>
  10. #include <sys/resource.h>
  11.  
  12.     
  13. #define RECV_OK    0
  14. #define RECV_EOF  -1
  15. #define NON_RESERVED_PORT 5001
  16.  
  17. char *sys_errlist[];
  18.  
  19. /* Macros to convert from integer to net byte order and vice versa */
  20. #define i_to_n(n)  (int) htonl( (u_long) n)
  21. #define n_to_i(n)  (int) ntohl( (u_long) n)
  22.  
  23. char buf[1000];
  24. struct sockaddr_in sin;
  25.  
  26. main(argc,argv)
  27. int argc;
  28. char *argv[];
  29. {
  30.  
  31.     if (argc == 3)
  32.     {
  33.     printf("calling client\n");
  34.     client(argv[1],atoi(argv[2]));
  35.     printf("back from client\n");
  36.     }
  37.     else
  38.     {
  39.     printf("calling server\n");
  40.     server();
  41.     printf("back from server\n");
  42.     }
  43. }
  44.  
  45. server()
  46. {
  47. int i, rc, ssocket, sfd;
  48. int optval = 1,optlen;
  49. int flags;
  50. int ntimes;
  51.  
  52.     setup_to_accept(5, NON_RESERVED_PORT, &ssocket);
  53.     sfd = accept_connection(ssocket);
  54.  
  55.     flags = fcntl(sfd, F_GETFL, 0);
  56.     if (flags < 0)
  57.     error_check(flags,"getfl");
  58.     flags |= O_NDELAY;
  59.     fcntl(sfd, F_SETFL, flags);
  60.     if (flags < 0)
  61.     error_check(flags,"setfl");
  62.  
  63.     setsockopt(sfd,IPPROTO_TCP,TCP_NODELAY,(char *)&optval,sizeof(optval));
  64.     rc = recv_msg(sfd, &ntimes, sizeof(int));
  65.     printf("received ntimes=%d\n",ntimes);
  66.     for (i=0; i < ntimes; i++)
  67.     {
  68.     while (!msgs_available(sfd))
  69.         ;
  70.     rc = recv_msg(sfd, buf, 4);    
  71.     rc = recv_msg(sfd, buf, 4);    
  72.     send_msg(sfd, buf, 4);
  73.     send_msg(sfd, buf, 4);
  74.     }
  75.     shutdown(sfd,0);
  76.     shutdown(ssocket,0);
  77.     unlink((char *)&sin);
  78. }
  79.  
  80. client(server_host,ntimes)
  81. char *server_host;
  82. int ntimes;
  83. {
  84. int i, cfd,rc;
  85. int optval = 1,optlen;
  86. int flags, start_time, end_time;
  87.  
  88.     cfd = connect_to_server(server_host,NON_RESERVED_PORT);
  89.     flags = fcntl(cfd, F_GETFL, 0);
  90.     if (flags < 0)
  91.     error_check(flags,"getfl");
  92.     flags |= O_NDELAY;
  93.     fcntl(cfd, F_SETFL, flags);
  94.     if (flags < 0)
  95.     error_check(flags,"setfl");
  96.  
  97.     setsockopt(cfd,IPPROTO_TCP,TCP_NODELAY,(char *)&optval,sizeof(optval));
  98.     printf("sending ntimes=%d\n",ntimes);
  99.     send_msg(cfd, &ntimes, sizeof(int));
  100.     start_time = getclock();
  101.     for (i=0; i < ntimes; i++)
  102.     {
  103.     send_msg(cfd, buf, 4);
  104.     send_msg(cfd, buf, 4);
  105.     while (!msgs_available(cfd))
  106.         ;
  107.     rc = recv_msg(cfd, buf, 4);    
  108.     rc = recv_msg(cfd, buf, 4);    
  109.     }
  110.     end_time = getclock();
  111.     printf("time=%d\n",end_time-start_time);
  112. }
  113.  
  114. msgs_available(fd)
  115. int fd;
  116. {
  117.     int nfds = 0;
  118.     fd_set read_fds;
  119.     struct timeval tv;
  120.  
  121.     FD_ZERO(&read_fds);
  122.     FD_SET(fd, &read_fds);
  123.     tv.tv_sec = 0;
  124.     tv.tv_usec = 0;
  125.     nfds = select(24, &read_fds, 0, 0, &tv);
  126.     if (nfds == -1)
  127.     {
  128.     error_check(nfds, "socket_send select");
  129.     }
  130.     return(nfds);
  131. }
  132.  
  133. recv_msg(fd, buf, size)    
  134. int fd;
  135. char *buf;
  136. int size;
  137. {
  138.     int recvd = 0;
  139.     int n;
  140.  
  141.     while (recvd < size)
  142.     {
  143.     n = read(fd, buf + recvd, size - recvd);
  144.         if (n < 0)
  145.         {
  146.         continue;
  147.             printf("%s :%d: %s\n","recvmsg ",n,sys_errlist[errno]);
  148.         return(0);
  149.         }
  150.     if (n > 0)
  151.         recvd += n;
  152.     }
  153.     return(recvd);
  154. }
  155.  
  156.  
  157. send_msg(fd, buf, size)    
  158. int fd;
  159. char *buf;
  160. int size;
  161. {
  162.     int sent = 0;
  163.     int sendsize,rc,n,nfds,done = 0;
  164.     fd_set read_fds;
  165.     struct timeval tv;
  166.  
  167.     while (sent < size)
  168.     {
  169.     if ((size - sent) > 4096)
  170.         sendsize = 4096;
  171.     else
  172.         sendsize = size - sent;
  173.         n = write(fd, buf + sent, sendsize);
  174.         if (n < 0)
  175.         {
  176.             printf("%s :%d: %s\n","send_msg ",n,sys_errlist[errno]);
  177.         return(0);
  178.         }
  179.         if (n > 0)
  180.             sent += n;
  181.     }
  182.     return(sent);
  183. }
  184.  
  185. setup_to_accept(backlog, port, skt)    
  186. int backlog;
  187. int port;
  188. int *skt;
  189. {
  190. int rc;
  191.  
  192.     sin.sin_family = AF_INET;
  193.     sin.sin_addr.s_addr = INADDR_ANY;
  194.     sin.sin_port = htons(port);
  195.  
  196.     *skt = socket(AF_INET, SOCK_STREAM, 0);
  197.     error_check(*skt,"net_setup_anon_listener socket");
  198.  
  199.     rc = bind(*skt, (struct sockaddr *)&sin ,sizeof(sin));
  200.     error_check(rc,"net_setup_listener bind");
  201.  
  202.     rc = listen(*skt, backlog);
  203.     error_check(rc,"net_setup_listener listen");
  204. }
  205.  
  206. int accept_connection(skt)    
  207. int skt;
  208. {
  209. struct sockaddr_in from;
  210. int fromlen;
  211. int skt2;
  212. int gotit;
  213.  
  214.     fromlen = sizeof(from);
  215.     gotit = 0;
  216.     while (!gotit)
  217.     {
  218.     skt2 = accept(skt, (struct sockaddr *) &from, &fromlen);
  219.     if (skt2 == -1)
  220.     {
  221.         if (errno == EINTR)
  222.         continue;
  223.         else
  224.         error_check(skt2, "accept_connection accept");
  225.     }
  226.     else
  227.         gotit = 1;
  228.     }
  229.  
  230.     return(skt2);
  231. }
  232.  
  233. connect_to_server(hostname, port)    
  234. char *hostname;
  235. int port;
  236. {
  237. int s;
  238. struct sockaddr_in listener;
  239. struct hostent *hp;
  240. int rc;
  241.  
  242.     hp = gethostbyname(hostname);
  243.     if (hp == NULL)
  244.     {
  245.     printf("connect_to_server: gethostbyname %s: %s -- exiting\n",
  246.         hostname, sys_errlist[errno]);
  247.     exit(99);
  248.     }
  249.  
  250.     bzero((void *)&listener, sizeof(listener));
  251.     bcopy((void *)hp->h_addr, (void *)&listener.sin_addr, hp->h_length);
  252.     listener.sin_family = hp->h_addrtype;
  253.     listener.sin_port = htons(port);
  254.  
  255.     s = socket(AF_INET, SOCK_STREAM, 0);
  256.     error_check(s, "net_connect_to_server socket");
  257.  
  258.     rc = connect(s,(struct sockaddr *) &listener, sizeof(listener));
  259.     error_check(rc, "net_connect_to_server connect");
  260.  
  261.     return(s);
  262. }
  263.  
  264. error_check(val, str)    
  265. int val;
  266. char *str;
  267. {
  268.     if (val < 0)
  269.     {
  270.     printf("%s :%d: %s\n", str, val, sys_errlist[errno]);
  271.     exit(1);
  272.     }
  273. }
  274.  
  275.  
  276. getclock()
  277. {
  278.     int i;
  279.     struct timeval tp;
  280.     struct timezone tzp;
  281.  
  282.     gettimeofday(&tp, &tzp);
  283.     i = (int) tp.tv_sec;
  284.     i *= 1000;
  285.     i += (int) (tp.tv_usec / 1000);
  286.     return(i);
  287. }
  288.